const { app, BrowserWindow, ipcMain } = require('electron');
const { startHttpServer } = require('./src/utils/httpserver');
const { createLoginWindow } = require('./src/login');
const sqlite3 = require('sqlite3').verbose();
const path = require('path');
const fs = require('fs');

// 启动HTTP服务器
startHttpServer();

// 数据库路径
const dbPath = path.resolve(__dirname, './data/mydatabase.db');

// 创建数据库
ipcMain.handle('create-database', async () => {
    try {
        // 确保数据目录存在
        const dir = path.dirname(dbPath);
        if (!fs.existsSync(dir)) {
            fs.mkdirSync(dir, { recursive: true });
        }

        const db = new sqlite3.Database(dbPath);
        await new Promise((resolve, reject) => {
            db.run(`CREATE TABLE IF NOT EXISTS cases (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                原始链接 TEXT,
                案号 TEXT,
                案件名称 TEXT,
                法院 TEXT,
                所属地区 TEXT,
                案件类型 TEXT,
                案件类型编码 TEXT,
                来源 TEXT,
                审理程序 TEXT,
                裁判日期 DATE,
                公开日期 DATE,
                当事人 TEXT,
                案由 TEXT,
                法律依据 TEXT,
                全文 TEXT
            )`, (err) => {
                if (err) {
                    reject(err);
                } else {
                    resolve();
                }
                db.close();
            });
        });
        return { message: '数据库表创建成功' };
    } catch (error) {
        throw new Error(`数据库创建错误: ${error.message}`);
    }
});

// 打开数据库连接
ipcMain.handle('open-database', async () => {
    return new Promise((resolve, reject) => {
        const db = new sqlite3.Database(dbPath, (err) => {
            if (err) {
                reject(new Error(`数据库连接错误: ${err.message}`));
            } else {
                resolve(db);
            }
        });
    });
});

// 分页大小
const PAGE_SIZE = 50;

// 获取分页数据
ipcMain.handle('get-csv-data', async (event, { page }) => {
    const db = new sqlite3.Database(dbPath);
    return new Promise((resolve, reject) => {
        db.serialize(() => {
            // 获取总行数
            db.get('SELECT COUNT(*) as total FROM cases', (err, row) => {
                if (err) {
                    reject(new Error(`获取总行数失败: ${err.message}`));
                    return;
                }

                const total = row.total;
                const offset = (page - 1) * PAGE_SIZE;
                
                // 查询分页数据
                db.all(
                    `SELECT * FROM cases LIMIT ? OFFSET ?`,
                    [PAGE_SIZE, offset],
                    (err, rows) => {
                        db.close();
                        if (err) {
                            reject(new Error(`查询失败: ${err.message}`));
                        } else {
                            resolve({
                                data: rows,
                                hasMore: offset + PAGE_SIZE < total
                            });
                        }
                    }
                );
            });
        });
    });
});

// 导入CSV数据
ipcMain.handle('import-csv-data', async (event, { headers, lines }) => {
    const db = new sqlite3.Database(dbPath);
    return new Promise((resolve, reject) => {
        db.serialize(() => {
            // 清空cases表
            db.run('DELETE FROM cases', (err) => {
                if (err) {
                    reject(new Error(`清空表失败: ${err.message}`));
                    return;
                }
            });

            const placeholders = headers.map(() => '?').join(',');
            const stmt = db.prepare(`INSERT INTO cases (
                原始链接, 案号, 案件名称, 法院, 所属地区, 
                案件类型, 案件类型编码, 来源, 审理程序, 
                裁判日期, 公开日期, 当事人, 案由, 法律依据, 全文
            ) VALUES (${placeholders})`);

            let insertedCount = 0;
            let errors = [];
            
            // 过滤并处理有效行
            lines.forEach((line, index) => {
                // 跳过空行
                if (!line || line.trim() === '') return;
                
                const values = line.split(',');
                // 验证列数匹配
                if (values.length !== headers.length) {
                    errors.push(`第${index + 1}行列数不匹配 (${values.length}列，应为${headers.length}列)`);
                    return;
                }
                
                // 验证关键字段
                const requiredFields = ['案号', '案件名称', '法院'];
                const missingFields = requiredFields.filter(field => {
                    const idx = headers.indexOf(field);
                    return idx === -1 || !values[idx]?.trim();
                });
                
                if (missingFields.length > 0) {
                    errors.push(`第${index + 1}行缺少必要字段: ${missingFields.join(', ')}`);
                    return;
                }

                // 插入数据
                stmt.run(values, (err) => {
                    if (err) {
                        errors.push(`第${index + 1}行插入失败: ${err.message}`);
                    } else {
                        insertedCount++;
                    }
                });
            });

            stmt.finalize((err) => {
                db.close();
                if (err || errors.length > 0) {
                    reject(new Error(`导入错误: ${errors.join('\n')}`));
                } else {
                    resolve({ insertedCount });
                }
            });
        });
    });
});

// 创建Electron窗口
function createWindow() {
    const mainWindow = new BrowserWindow({
        width: 2000,
        height: 800,
        webPreferences: {
            nodeIntegration: true,
            contextIsolation: false,
        },
    });

    mainWindow.loadFile('public/index.html');
}

app.whenReady().then(createWindow);

app.on('window-all-closed', () => {
    if (process.platform !== 'darwin') {
        app.quit();
    }
});

app.on('activate', () => {
    if (BrowserWindow.getAllWindows().length === 0) {
        createWindow();
    }
});
